// pages/staff/consults/chat.js
const app = getApp()

Page({

  /**
   * 页面的初始数据
   */
  data: {
    conversationId: null,  // 会话ID
    userId: null,          // 用户ID
    staffId: null,         // 医护人员ID
    userInfo: {},          // 用户信息
    staffInfo: {},         // 医护人员信息
    messages: [],          // 消息列表
    inputMessage: '',      // 输入框消息
    scrollToMessage: '',   // 滚动到哪条消息
    pageNum: 1,            // 当前页码
    pageSize: 20,          // 每页条数
    hasMore: true,         // 是否有更多历史消息
    isLoading: false,       // 是否正在加载
    token: null            // 保存token便于后续判断
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    const conversationId = options.id
    if (!conversationId) {
      wx.showToast({
        title: '会话ID不存在',
        icon: 'error'
      })
      setTimeout(() => {
        wx.navigateBack()
      }, 1500)
      return
    }

    // 尝试从多个可能的存储键获取医护人员信息
    let staffInfo = wx.getStorageSync('userInfo') || wx.getStorageSync('staffInfo') || {};
    let staffId = staffInfo.id;
    
    // 获取token，如果有token就认为已登录
    const token = wx.getStorageSync('token');
    
    // 如果没有staffId但有token，尝试从当前页面参数或全局数据获取
    if (!staffId && token) {
      // 尝试从app.globalData获取
      if (app.globalData && app.globalData.userInfo) {
        staffInfo = app.globalData.userInfo;
        staffId = staffInfo.id;
      }
      
      // 如果还是没有，临时使用一个ID，后续会从API请求中获取
      if (!staffId) {
        console.log('未找到医护人员ID，将在API请求中获取');
        // 不中断流程，继续执行
        staffId = options.staffId || 0; // 尝试从页面参数获取，否则临时用0
      }
    }
    
    console.log('加载聊天页面，会话ID:', conversationId, '医护人员ID:', staffId, '已登录状态:', !!token);
    
    this.setData({
      conversationId,
      staffId,
      staffInfo,
      token: token // 保存token便于后续判断
    })
    
    // 不管staffId是否存在，都尝试获取会话详情和消息列表
    // 因为可能在请求过程中从响应中获取到正确的用户信息
    
    // 获取会话详情
    this.getConversationDetail()
    
    // 获取消息列表
    this.getMessageList()
  },

  /**
   * 获取会话详情
   */
  getConversationDetail() {
    if (!this.data.token) {
      console.error('未找到Token，无法获取会话详情');
      wx.showToast({
        title: '登录状态已过期，请重新登录',
        icon: 'none'
      });
      return;
    }
    
    wx.request({
      url: `${app.globalData.baseUrl}/consult/conversation/staff/recent`,
      method: 'GET',
      data: {
        limit: 1,
        conversationId: this.data.conversationId
      },
      header: {
        'Authorization': `Bearer ${this.data.token}`
      },
      success: (res) => {
        console.log('获取会话详情响应:', res.data)
        if (res.data.code === 200) {
          // 查找指定conversationId的会话
          const conversations = res.data.data || [];
          const conversation = conversations.find(item => item.id == this.data.conversationId);
          
          // 如果未找到指定会话，尝试使用第一个会话
          const firstConversation = conversations[0];
          const validConversation = conversation || firstConversation;
          
          console.log('找到会话信息:', validConversation);
          
          if (validConversation) {
            // 如果响应中返回了staffId，更新本地存储的staffId
            if (validConversation.staffId && !this.data.staffId) {
              console.log('从API响应中获取到staffId:', validConversation.staffId);
              this.setData({
                staffId: validConversation.staffId
              });
            }
            
            // 如果staffId还是空的，尝试使用登录用户的ID
            if (!this.data.staffId) {
              const loginInfo = wx.getStorageSync('loginInfo');
              if (loginInfo && loginInfo.id) {
                console.log('从loginInfo获取staffId:', loginInfo.id);
                this.setData({
                  staffId: loginInfo.id
                });
              } else {
                // 最后尝试从请求头中的token解析
                try {
                  const token = this.data.token;
                  if (token) {
                    const tokenParts = token.split('.');
                    if (tokenParts.length === 3) {
                      const payload = JSON.parse(atob(tokenParts[1]));
                      if (payload.userId) {
                        console.log('从token中解析出userId:', payload.userId);
                        this.setData({
                          staffId: payload.userId
                        });
                      }
                    }
                  }
                } catch(e) {
                  console.error('从token解析用户ID失败:', e);
                }
              }
            }
            
            // 保存用户信息
            this.setData({
              userId: validConversation.userId,
              userInfo: {
                id: validConversation.userId,
                name: validConversation.userName,
                avatar: validConversation.userAvatar
              }
            });
            
            console.log('已设置用户信息:', {
              staffId: this.data.staffId,
              userId: this.data.userId
            });
          } else {
            console.error('API返回成功但未找到会话信息');
            wx.showToast({
              title: '未找到会话信息',
              icon: 'none'
            });
          }
        } else {
          // 如果返回未登录错误，提示用户登录
          if (res.data.code === 401 || res.data.message && res.data.message.includes('登录')) {
            wx.showToast({
              title: '请先登录',
              icon: 'none'
            });
            setTimeout(() => {
              wx.navigateTo({
                url: '/pages/login/login'  // 假设登录页面路径
              });
            }, 1500);
          } else {
            wx.showToast({
              title: res.data.message || '获取会话详情失败',
              icon: 'none'
            });
          }
        }
      },
      fail: (err) => {
        console.error('获取会话详情请求失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  /**
   * 获取消息列表
   */
  getMessageList(append = false) {
    if (this.data.isLoading) return
    if (!this.data.token) {
      console.error('未找到Token，无法获取消息列表');
      return;
    }

    this.setData({
      isLoading: true
    })

    console.log('开始获取消息列表，conversationId:', this.data.conversationId)

    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/${this.data.conversationId}`,
      method: 'GET',
      data: {
        page: this.data.pageNum,
        size: this.data.pageSize
      },
      header: {
        'Authorization': `Bearer ${this.data.token}`
      },
      success: (res) => {
        console.log('获取消息列表响应:', res.data)
        
        if (res.data.code === 200) {
          const newMessages = res.data.data.records || []
          const total = res.data.data.total || 0
          const hasMore = this.data.pageNum * this.data.pageSize < total
          
          console.log('原始消息列表:', newMessages)
          
          // 格式化消息
          const formattedMessages = newMessages.map(msg => {
            // 处理消息内容
            let content = msg.content
            if (content) {
              // 如果是BLOB格式，尝试解码
              if (content.type === 'Buffer' && Array.isArray(content.data)) {
                try {
                  content = String.fromCharCode.apply(null, content.data)
                } catch (e) {
                  console.error('Buffer解码失败:', e)
                  content = '[消息内容解析失败]'
                }
              } else if (typeof content === 'object') {
                try {
                  content = JSON.stringify(content)
                } catch (e) {
                  console.error('消息内容格式化失败:', e)
                  content = '[消息内容解析失败]'
                }
              }
            } else {
              content = '';
            }
            
            // 格式化时间
            let formattedTime = msg.createTime
            if (formattedTime) {
              try {
                const date = new Date(formattedTime.replace(' ', 'T'))
                formattedTime = `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`
              } catch (e) {
                console.error('时间格式化失败:', e)
                formattedTime = msg.createTime
              }
            }
            
            // 确保senderType字段正确
            let senderType = msg.senderType
            if (senderType === undefined || senderType === null) {
              // 根据senderId判断发送者类型
              senderType = (msg.senderId === this.data.staffId) ? 1 : 0
            }
            
            console.log(`消息ID:${msg.id}, 发送者ID:${msg.senderId}, 发送者类型:${senderType}, 内容:${content.substring(0, 20)}...`)
            
            return {
              ...msg,
              content: content,
              createTime: formattedTime,
              senderType: senderType // 确保有正确的发送者类型
            }
          })
          
          console.log('格式化后的消息列表:', formattedMessages)
          
          if (append) {
            // 加载更多时，将新消息添加到列表前面
            const updatedMessages = [...formattedMessages, ...this.data.messages]
            console.log('追加后的消息列表:', updatedMessages)
            
            this.setData({
              messages: updatedMessages,
              hasMore,
              isLoading: false
            })
          } else {
            // 首次加载或刷新时，直接设置消息列表
            console.log('设置新的消息列表:', formattedMessages)
            
            this.setData({
              messages: formattedMessages,
              hasMore,
              isLoading: false
            })
            
            // 滚动到最新消息
            if (formattedMessages.length > 0) {
              this.setData({
                scrollToMessage: `msg-${formattedMessages[formattedMessages.length - 1].id}`
              })
            }
          }
        } else {
          console.error('获取消息列表失败:', res.data)
          this.setData({ isLoading: false })
          
          // 如果返回未登录错误，提示用户登录
          if (res.data.code === 401 || res.data.message && res.data.message.includes('登录')) {
            wx.showToast({
              title: '请先登录',
              icon: 'none'
            });
          } else {
            wx.showToast({
              title: res.data.message || '获取消息失败',
              icon: 'none'
            });
          }
        }
      },
      fail: (err) => {
        console.error('获取消息列表请求失败:', err)
        this.setData({ isLoading: false })
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  /**
   * 发送消息
   */
  sendMessage() {
    const content = this.data.inputMessage.trim()
    if (!content) return
    
    if (!this.data.token) {
      console.error('未找到Token，无法发送消息');
      wx.showToast({
        title: '登录状态已过期，请重新登录',
        icon: 'none'
      });
      return;
    }
    
    console.log('发送消息前的用户信息:', {
      staffId: this.data.staffId,
      userId: this.data.userId
    });
    
    // 如果缺少用户ID，尝试从页面参数、路由或URL中获取
    if (!this.data.userId) {
      const pages = getCurrentPages();
      const currentPage = pages[pages.length - 1];
      const options = currentPage.options || {};
      const possibleUserId = options.userId || this.data.conversationId;
      
      if (possibleUserId) {
        console.log('从页面参数中恢复userId:', possibleUserId);
        this.setData({
          userId: possibleUserId
        });
      }
    }
    
    // 如果缺少staffId，尝试固定值进行发送
    if (!this.data.staffId && this.data.userId) {
      console.log('未找到staffId，使用临时staffId进行发送');
      this.setData({
        staffId: wx.getStorageSync('staffId') || 2 // 假设医生的ID是2
      });
    }
    
    if (!this.data.staffId || !this.data.userId) {
      console.error(`缺少必要的用户信息，无法发送消息: staffId=${this.data.staffId}, userId=${this.data.userId}`);
      wx.showToast({
        title: '无法获取用户信息',
        icon: 'none',
        duration: 2000
      });
      
      // 尝试重新获取会话详情
      setTimeout(() => {
        this.getConversationDetail();
      }, 2000);
      
      return;
    }
    
    console.log('准备发送消息:', {
      content,
      senderId: this.data.staffId,
      senderType: 1, // 1表示医护人员
      receiverId: this.data.userId,
      receiverType: 0 // 0表示用户
    })
    
    const message = {
      content: content,
      senderId: this.data.staffId,
      senderType: 1, // 1表示医护人员
      receiverId: this.data.userId,
      receiverType: 0 // 0表示用户
    }

    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/${this.data.conversationId}`,
      method: 'POST',
      data: message,
      header: {
        'Authorization': `Bearer ${this.data.token}`,
        'Content-Type': 'application/json'
      },
      success: (res) => {
        console.log('发送消息响应:', res.data)
        
        if (res.data.code === 200) {
          // 清空输入框
          this.setData({
            inputMessage: ''
          })
          
          // 手动添加消息到列表，避免等待刷新
          const newMessage = {
            id: new Date().getTime(), // 临时ID
            conversationId: this.data.conversationId,
            content: content,
            senderId: this.data.staffId,
            senderType: 1, // 1表示医护人员
            receiverId: this.data.userId,
            receiverType: 0, // 0表示用户
            createTime: new Date().toTimeString().split(' ')[0].substring(0, 5)
          };
          
          this.setData({
            messages: [...this.data.messages, newMessage],
            scrollToMessage: `msg-${newMessage.id}`
          });
          
          // 保存正确的staffId，方便下次使用
          if (this.data.staffId) {
            wx.setStorageSync('staffId', this.data.staffId);
          }
          
          // 延迟刷新消息列表，获取服务器最新数据
          setTimeout(() => {
            this.setData({
              pageNum: 1
            });
            this.getMessageList();
          }, 1000);
        } else {
          console.error('发送消息失败:', res.data)
          
          // 如果返回未登录错误，提示用户登录
          if (res.data.code === 401 || res.data.message && res.data.message.includes('登录')) {
            wx.showToast({
              title: '请先登录',
              icon: 'none'
            });
          } else {
            wx.showToast({
              title: res.data.message || '发送失败',
              icon: 'none'
            });
          }
        }
      },
      fail: (err) => {
        console.error('发送消息请求失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  /**
   * 输入框内容变化
   */
  onInputChange(e) {
    this.setData({
      inputMessage: e.detail.value
    })
  },

  /**
   * 加载更多历史消息
   */
  loadMoreMessages() {
    if (!this.data.hasMore || this.data.isLoading) return
    
    this.setData({
      pageNum: this.data.pageNum + 1
    })
    
    this.getMessageList(true)
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 标记消息为已读
    this.markMessagesAsRead()

    // 定时刷新消息列表
    this.startMessageRefresh()
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {
    // 停止定时刷新
    this.stopMessageRefresh()
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    // 停止定时刷新
    this.stopMessageRefresh()
  },

  /**
   * 标记消息为已读
   */
  markMessagesAsRead() {
    if (!this.data.token || !this.data.conversationId) {
      console.log('缺少Token或会话ID，跳过标记已读');
      return;
    }
    
    wx.request({
      url: `${app.globalData.baseUrl}/consult/message/read/${this.data.conversationId}`,
      method: 'POST',
      header: {
        'Authorization': `Bearer ${this.data.token}`
      },
      success: (res) => {
        console.log('标记消息已读结果:', res.data);
      },
      fail: (err) => {
        console.error('标记消息已读失败', err)
      }
    })
  },

  /**
   * 开始定时刷新消息
   */
  startMessageRefresh() {
    // 每10秒刷新一次
    this.messageRefreshTimer = setInterval(() => {
      // 只刷新第一页
      this.setData({ pageNum: 1 })
      this.getMessageList()
    }, 10000)
  },

  /**
   * 停止定时刷新
   */
  stopMessageRefresh() {
    if (this.messageRefreshTimer) {
      clearInterval(this.messageRefreshTimer)
      this.messageRefreshTimer = null
    }
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  }
})